type math/big.nat

246 uses

	math/big (current package)
		decimal.go#L55: func (x *decimal) init(m nat, shift int) {
		decimal.go#L72: 		m = nat(nil).shr(m, s)
		decimal.go#L78: 		m = nat(nil).shl(m, uint(shift))
		float.go#L71: 	mant nat
		float.go#L583: func fnorm(m nat) int64 {
		float.go#L697: func msb32(x nat) uint32 {
		float.go#L715: func msb64(x nat) uint64 {
		float.go#L1239: 			t := nat(nil).shl(y.mant, uint(ey-ex))
		float.go#L1250: 			t := nat(nil).shl(x.mant, uint(ex-ey))
		float.go#L1284: 			t := nat(nil).shl(y.mant, uint(ey-ex))
		float.go#L1295: 			t := nat(nil).shl(x.mant, uint(ex-ey))
		float.go#L1356: 		xadj = make(nat, len(x.mant)+d)
		float.go#L1368: 	var r nat
		ftoa.go#L186: 	mant := nat(nil).set(x.mant)
		ftoa.go#L200: 	var tmp nat
		ftoa.go#L332: 		m = nat(nil).shl(m, uint(x.prec-w))
		ftoa.go#L334: 		m = nat(nil).shr(m, uint(w-x.prec))
		ftoa.go#L383: 		m = nat(nil).shl(m, n-w)
		ftoa.go#L385: 		m = nat(nil).shr(m, w-n)
		int.go#L35: 	abs nat  // absolute value of the integer
		int.go#L122: 	z.abs = nat(abs).norm()
		int.go#L277: 	_, z.abs = nat(nil).div(z.abs, x.abs, y.abs)
		int.go#L404: func low32(x nat) uint32 {
		int.go#L412: func low64(x nat) uint64 {
		int.go#L589: 	var mWords nat
		int.go#L930: func (z nat) modInverse(g, n nat) nat {
		int.go#L1147: 		t := nat(nil).sub(x.abs, natOne)
		int.go#L1179: 			x1 := nat(nil).sub(x.abs, natOne)
		int.go#L1180: 			y1 := nat(nil).sub(y.abs, natOne)
		int.go#L1198: 	y1 := nat(nil).sub(y.abs, natOne)
		int.go#L1209: 			x1 := nat(nil).sub(x.abs, natOne)
		int.go#L1210: 			y1 := nat(nil).sub(y.abs, natOne)
		int.go#L1224: 		x1 := nat(nil).sub(x.abs, natOne)
		int.go#L1231: 	y1 := nat(nil).sub(y.abs, natOne)
		int.go#L1242: 			x1 := nat(nil).sub(x.abs, natOne)
		int.go#L1243: 			y1 := nat(nil).sub(y.abs, natOne)
		int.go#L1261: 	y1 := nat(nil).sub(y.abs, natOne)
		int.go#L1272: 			x1 := nat(nil).sub(x.abs, natOne)
		int.go#L1273: 			y1 := nat(nil).sub(y.abs, natOne)
		int.go#L1291: 	y1 := nat(nil).sub(y.abs, natOne)
		nat.go#L34: type nat []Word
		nat.go#L37: 	natOne  = nat{1}
		nat.go#L38: 	natTwo  = nat{2}
		nat.go#L39: 	natFive = nat{5}
		nat.go#L40: 	natTen  = nat{10}
		nat.go#L43: func (z nat) String() string {
		nat.go#L47: func (z nat) clear() {
		nat.go#L53: func (z nat) norm() nat {
		nat.go#L61: func (z nat) make(n int) nat {
		nat.go#L67: 		return make(nat, 1)
		nat.go#L72: 	return make(nat, n, n+e)
		nat.go#L75: func (z nat) setWord(x Word) nat {
		nat.go#L84: func (z nat) setUint64(x uint64) nat {
		nat.go#L96: func (z nat) set(x nat) nat {
		nat.go#L102: func (z nat) add(x, y nat) nat {
		nat.go#L128: func (z nat) sub(x, y nat) nat {
		nat.go#L156: func (x nat) cmp(y nat) (r int) {
		nat.go#L183: func (z nat) mulAddWW(x nat, y, r Word) nat {
		nat.go#L198: func basicMul(z, x, y nat) {
		nat.go#L216: func (z nat) montgomery(x, y, m nat, k Word, n int) nat {
		nat.go#L251: func karatsubaAdd(z, x nat, n int) {
		nat.go#L258: func karatsubaSub(z, x nat, n int) {
		nat.go#L273: func karatsuba(z, x, y nat) {
		nat.go#L374: func alias(x, y nat) bool {
		nat.go#L381: func addAt(z, x nat, i int) {
		nat.go#L412: func (z nat) mul(x, y nat) nat {
		nat.go#L503: func basicSqr(z, x nat) {
		nat.go#L526: func karatsubaSqr(z, x nat) {
		nat.go#L564: func (z nat) sqr(x nat) nat {
		nat.go#L622: func (z nat) mulRange(a, b uint64) nat {
		nat.go#L632: 		return z.mul(nat(nil).setUint64(a), nat(nil).setUint64(b))
		nat.go#L635: 	return z.mul(nat(nil).mulRange(a, m), nat(nil).mulRange(m+1, b))
		nat.go#L640: func getNat(n int) *nat {
		nat.go#L641: 	var z *nat
		nat.go#L643: 		z = v.(*nat)
		nat.go#L646: 		z = new(nat)
		nat.go#L655: func putNat(x *nat) {
		nat.go#L663: func (x nat) bitLen() int {
		nat.go#L685: func (x nat) trailingZeroBits() uint {
		nat.go#L698: func (x nat) isPow2() (uint, bool) {
		nat.go#L709: func same(x, y nat) bool {
		nat.go#L714: func (z nat) shl(x nat, s uint) nat {
		nat.go#L739: func (z nat) shr(x nat, s uint) nat {
		nat.go#L762: func (z nat) setBit(x nat, i uint, b uint) nat {
		nat.go#L792: func (x nat) bit(i uint) uint {
		nat.go#L803: func (x nat) sticky(i uint) uint {
		nat.go#L823: func (z nat) and(x, y nat) nat {
		nat.go#L840: func (z nat) trunc(x nat, n uint) nat {
		nat.go#L853: func (z nat) andNot(x, y nat) nat {
		nat.go#L870: func (z nat) or(x, y nat) nat {
		nat.go#L889: func (z nat) xor(x, y nat) nat {
		nat.go#L910: func (z nat) random(rand *rand.Rand, limit nat, n int) nat {
		nat.go#L946: func (z nat) expNN(x, y, m nat, slow bool) nat {
		nat.go#L1009: 	var q nat
		nat.go#L1020: 	var zz, r nat
		nat.go#L1070: func (z nat) expNNMontgomeryEven(x, y, m nat) nat {
		nat.go#L1073: 	m1 := nat(nil).shl(natOne, n)
		nat.go#L1074: 	m2 := nat(nil).shr(m, n)
		nat.go#L1082: 	z1 := nat(nil).expNN(x, y, m1, false)
		nat.go#L1083: 	z2 := nat(nil).expNN(x, y, m2, false)
		nat.go#L1101: 	m2inv := nat(nil).modInverse(m2, m1)
		nat.go#L1113: func (z nat) expNNWindowed(x, y nat, logM uint) nat {
		nat.go#L1134: 	var powers [1 << n]*nat
		nat.go#L1212: func (z nat) expNNMontgomery(x, y, m nat) nat {
		nat.go#L1218: 		_, x = nat(nil).div(nil, x, m)
		nat.go#L1222: 		rr := make(nat, numWords)
		nat.go#L1239: 	RR := nat(nil).setWord(1)
		nat.go#L1240: 	zz := nat(nil).shl(RR, uint(2*numWords*_W))
		nat.go#L1241: 	_, RR = nat(nil).div(RR, zz, m)
		nat.go#L1248: 	one := make(nat, numWords)
		nat.go#L1253: 	var powers [1 << n]nat
		nat.go#L1296: 			_, zz = nat(nil).div(nil, zz, m)
		nat.go#L1307: func (z nat) bytes(buf []byte) (i int) {
		nat.go#L1344: func (z nat) setBytes(buf []byte) nat {
		nat.go#L1365: func (z nat) sqrt(x nat) nat {
		nat.go#L1378: 	var z1, z2 nat
		nat.go#L1399: func (z nat) subMod2N(x, y nat, n uint) nat {
		nat.go#L1405: 			x = nat(nil).trunc(x, n)
		nat.go#L1413: 			y = nat(nil).trunc(y, n)
		natconv.go#L108: func (z nat) scan(r io.ByteScanner, base int, fracOk bool) (res nat, b, count int, err error) {
		natconv.go#L258: func (x nat) utoa(base int) []byte {
		natconv.go#L263: func (x nat) itoa(neg bool, base int) []byte {
		natconv.go#L331: 		q := nat(nil).set(x)
		natconv.go#L368: func (q nat) convertWords(s []byte, b Word, ndigits int, bb Word, table []divisor) {
		natconv.go#L372: 		var r nat
		natconv.go#L443: 	bbb     nat // divisor
		natconv.go#L454: func (z nat) expWW(x, y Word) nat {
		natconv.go#L455: 	return z.expNN(nat(nil).setWord(x), nat(nil).setWord(y), nil, false)
		natconv.go#L483: 		var larger nat
		natconv.go#L487: 					table[0].bbb = nat(nil).expWW(bb, Word(leafSize))
		natconv.go#L490: 					table[i].bbb = nat(nil).sqr(table[i-1].bbb)
		natconv.go#L495: 				larger = nat(nil).set(table[i].bbb)
		natdiv.go#L505: func (z nat) rem(u, v nat) (r nat) {
		natdiv.go#L518: func (z nat) div(z2, u, v nat) (q, r nat) {
		natdiv.go#L545: func (z nat) divW(x nat, y Word) (q nat, r Word) {
		natdiv.go#L565: func (x nat) modW(d Word) (r Word) {
		natdiv.go#L567: 	var q nat
		natdiv.go#L592: func (z nat) divLarge(u, uIn, vIn nat) (q, r nat) {
		natdiv.go#L634: func (q nat) divBasic(u, v nat) {
		natdiv.go#L729: func (z nat) divRecursive(u, v nat) {
		natdiv.go#L735: 	temps := make([]*nat, recDepth)
		natdiv.go#L754: func (z nat) divRecursiveStep(u, v nat, depth int, tmp *nat, temps []*nat) {
		prime.go#L86: func (n nat) probablyPrimeMillerRabin(reps int, force2 bool) bool {
		prime.go#L87: 	nm1 := nat(nil).sub(n, natOne)
		prime.go#L90: 	q := nat(nil).shr(nm1, k)
		prime.go#L92: 	nm3 := nat(nil).sub(nm1, natTwo)
		prime.go#L95: 	var x, y, quotient nat
		prime.go#L150: func (n nat) probablyPrimeLucas() bool {
		prime.go#L169: 	d := nat{1}
		prime.go#L170: 	t1 := nat(nil) // temp
		prime.go#L216: 	s := nat(nil).add(n, natOne)
		prime.go#L219: 	nm2 := nat(nil).sub(n, natTwo) // n-2
		prime.go#L249: 	natP := nat(nil).setWord(p)
		prime.go#L250: 	vk := nat(nil).setWord(2)
		prime.go#L251: 	vk1 := nat(nil).setWord(p)
		prime.go#L252: 	t2 := nat(nil) // temp
		rat.go#L77: func quotToFloat32(a, b nat) (f float32, exact bool) {
		rat.go#L111: 	var a2, b2 nat
		rat.go#L123: 	var q nat
		rat.go#L175: func quotToFloat64(a, b nat) (f float64, exact bool) {
		rat.go#L209: 	var a2, b2 nat
		rat.go#L221: 	var q nat
		rat.go#L310: 		babs = nat(nil).set(babs) // make a copy
		rat.go#L425: 		return &Int{abs: nat{1}}
		rat.go#L456: func mulDenom(z, x, y nat) nat {
		rat.go#L470: func (z *Int) scaleDenom(x *Int, f nat) {
		ratconv.go#L181: 		pow5 := z.b.abs.expNN(natFive, nat(nil).setWord(Word(n)), nil, false) // use underlying array of z.b.abs
		ratconv.go#L345: 	q, r := nat(nil).div(nat(nil), x.a.abs, x.b.abs)
		ratconv.go#L349: 		p = nat(nil).expNN(natTen, nat(nil).setUint64(uint64(prec)), nil, false)
		ratconv.go#L353: 	r, r2 := r.div(nat(nil), r, x.b.abs)
		ratconv.go#L360: 			q = nat(nil).add(q, natOne)
		ratconv.go#L361: 			r = nat(nil).sub(r, p)